error.h

Go to the documentation of this file.

 
#ifndef MRUBY_ERROR_H
#define MRUBY_ERROR_H
 
#include "common.h"
#include <string.h>

MRB_BEGIN_DECL
 
struct RException {
  MRB_OBJECT_HEADER;
  struct iv_tbl *iv;
  struct RBasic *mesg;         // NULL or probably RString
  struct RBasic *backtrace;    // NULL, RArray or RData
};
 
/* error that should terminate execution */
#define MRB_EXC_EXIT 65536
#define MRB_EXC_EXIT_P(e) ((e)->flags & MRB_EXC_EXIT)
/* retrieve status value from exc; need <mruby/variable.h> and <mruby/presym.h> */
#define MRB_EXC_EXIT_STATUS(mrb,e) ((int)mrb_as_int((mrb),mrb_obj_iv_get((mrb),(e),MRB_SYM(status))))
/* exit with SystemExit status */
#define MRB_EXC_CHECK_EXIT(mrb,e) do {if (MRB_EXC_EXIT_P(e)) exit(MRB_EXC_EXIT_STATUS((mrb),(e)));} while (0)
 
#define mrb_exc_ptr(v) ((struct RException*)mrb_ptr(v))
 
MRB_API mrb_noreturn void mrb_sys_fail(mrb_state *mrb, const char *mesg);
MRB_API mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str);
#define mrb_exc_new_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit))
MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_value args, const char *fmt, ...);
 
/* On 32-bit platforms whose ABI gives uint64_t/double 8-byte alignment
   (ARM, MIPS, PowerPC, xtensa, ...), embedding mrb_value directly in
   RBreak forces 8-byte alignment that pushes the struct past the 5-word
   RVALUE budget via padding.  Store the value bits as a uint32_t array
   (4-byte aligned) to dodge that padding.  Word-boxing's mrb_value is
   just a uintptr_t with no over-alignment, and 64-bit platforms have no
   alignment gap to begin with, so neither needs the workaround. */
#if defined(MRB_64BIT) || defined(MRB_WORD_BOXING)
#undef MRB_USE_RBREAK_VALUE_UNION
#else
#define MRB_USE_RBREAK_VALUE_UNION 1
#endif
 
/*
 *  flags:
 *      0..7:   enum mrb_vtype (only when MRB_USE_RBREAK_VALUE_UNION and
 *              !MRB_NAN_BOXING; nan-boxing encodes the type in the bits)
 *      8..10:  RBREAK_TAGs in src/vm.c (otherwise, set to 0)
 */
struct RBreak {
  MRB_OBJECT_HEADER;
  uintptr_t ci_break_index; // The top-level ci index to break. One before the return destination.
#ifndef MRB_USE_RBREAK_VALUE_UNION
  mrb_value val;
#elif defined(MRB_NAN_BOXING)
  /* nan-boxing: mrb_value is a single 64-bit word (type encoded in NaN bits) */
  uint32_t value[sizeof(mrb_value) / sizeof(uint32_t)];
#else
  /* no-boxing: store only the union bits; tt goes in flags */
  uint32_t value[sizeof(union mrb_value_union) / sizeof(uint32_t)];
#endif
};
 
#ifndef MRB_USE_RBREAK_VALUE_UNION
#define mrb_break_value_get(brk) ((brk)->val)
#define mrb_break_value_set(brk, v) ((brk)->val = v)
#elif defined(MRB_NAN_BOXING)
static inline mrb_value
mrb_break_value_get(struct RBreak *brk)
{
  mrb_value val;
  memcpy(&val, brk->value, sizeof(val));
  return val;
}
static inline void
mrb_break_value_set(struct RBreak *brk, mrb_value val)
{
  memcpy(brk->value, &val, sizeof(val));
}
#else
#define RBREAK_VALUE_TT_MASK ((1 << 8) - 1)
static inline mrb_value
mrb_break_value_get(struct RBreak *brk)
{
  mrb_value val;
  memcpy(&val.value, brk->value, sizeof(val.value));
  val.tt = (enum mrb_vtype)(brk->flags & RBREAK_VALUE_TT_MASK);
  return val;
}
static inline void
mrb_break_value_set(struct RBreak *brk, mrb_value val)
{
  memcpy(brk->value, &val.value, sizeof(val.value));
  brk->flags &= ~RBREAK_VALUE_TT_MASK;
  brk->flags |= val.tt;
}
#endif  /* MRB_USE_RBREAK_VALUE_UNION */

/* clear error status in the mrb_state structure */
MRB_API void mrb_clear_error(mrb_state *mrb);
/* returns TRUE if error in the previous call; internally calls mrb_clear_error() */
MRB_API mrb_bool mrb_check_error(mrb_state *mrb);

typedef mrb_value mrb_protect_error_func(mrb_state *mrb, void *userdata);
MRB_API mrb_value mrb_protect_error(mrb_state *mrb, mrb_protect_error_func *body, void *userdata, mrb_bool *error);

MRB_API mrb_value mrb_protect(mrb_state *mrb, mrb_func_t body, mrb_value data, mrb_bool *state);

MRB_API mrb_value mrb_ensure(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
                             mrb_func_t ensure, mrb_value e_data);

MRB_API mrb_value mrb_rescue(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
                             mrb_func_t rescue, mrb_value r_data);

MRB_API mrb_value mrb_rescue_exceptions(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
                                        mrb_func_t rescue, mrb_value r_data,
                                        mrb_int len, struct RClass **classes);

#define MRB_ENSURE(mrb, result_var, func, data) \
        for (mrb_bool MRB_UNIQNAME(_break_) = FALSE; \
             !MRB_UNIQNAME(_break_) && \
                (((result_var) = mrb_protect_error(mrb, func, data, &MRB_UNIQNAME(_break_))), \
                 ((mrb)->exc = (MRB_UNIQNAME(_break_) ? mrb_obj_ptr((result_var)) : NULL)), \
                 TRUE); \
             (void)(MRB_UNIQNAME(_break_) && (mrb)->jmp && (mrb_exc_raise(mrb, result_var), TRUE)), \
                MRB_UNIQNAME(_break_) = TRUE)
 
MRB_END_DECL
 
#endif  /* MRUBY_ERROR_H */